home *** CD-ROM | disk | FTP | other *** search
/ Ham Radio 2000 / Ham Radio 2000.iso / ham2000 / tcp_ip / os2 / pmnos11s / pppcmd.c < prev    next >
C/C++ Source or Header  |  1993-07-30  |  12KB  |  538 lines
  1. /*
  2.  *  PPPCMD.C    -- PPP related user commands
  3.  *
  4.  *    This implementation of PPP is declared to be in the public domain.
  5.  *
  6.  *    Jan 91    Bill_Simpson@um.cc.umich.edu
  7.  *        Computer Systems Consulting Services
  8.  *
  9.  *    Acknowledgements and correction history may be found in PPP.C
  10.  */
  11.  
  12. #include <stdio.h>
  13. #include "global.h"
  14. #include "mbuf.h"
  15. #include "iface.h"
  16. #include "pktdrvr.h"
  17. #include "ppp.h"
  18. #include "pppfsm.h"
  19. #include "ppplcp.h"
  20. #include "ppppap.h"
  21. #include "pppipcp.h"
  22. #include "cmdparse.h"
  23.  
  24. static struct iface *ppp_lookup __ARGS((char *ifname));
  25.  
  26. static int doppp_quick        __ARGS((int argc, char *argv[], void *p));
  27. static int doppp_trace        __ARGS((int argc, char *argv[], void *p));
  28.  
  29. static int spot __ARGS((int16 work,int16 want,int16 will,int16 mask));
  30. static void genstat        __ARGS((struct ppp_s *ppp_p));
  31. static void lcpstat        __ARGS((struct fsm_s *fsm_p));
  32. static void papstat        __ARGS((struct fsm_s *fsm_p));
  33. static void ipcpstat        __ARGS((struct fsm_s *fsm_p));
  34.  
  35. static int dotry_nak        __ARGS((int argc, char *argv[], void *p));
  36. static int dotry_req        __ARGS((int argc, char *argv[], void *p));
  37. static int dotry_terminate    __ARGS((int argc, char *argv[], void *p));
  38.  
  39.  
  40. /* "ppp" subcommands */
  41. static struct cmds Pppcmds[] = {
  42.     "ipcp",        doppp_ipcp,    0,    0,    NULLCHAR,
  43.     "lcp",        doppp_lcp,    0,    0,    NULLCHAR,
  44.     "pap",        doppp_pap,    0,    0,    NULLCHAR,
  45.     "quick",    doppp_quick,    0,    0,    NULLCHAR,
  46.     "trace",    doppp_trace,    0,    0,    NULLCHAR,
  47.     NULLCHAR,
  48. };
  49.  
  50. /* "ppp <iface> <ncp> try" subcommands */
  51. static struct cmds PppTrycmds[] = {
  52.     "configure",    dotry_req,    0,    0,    NULLCHAR,
  53.     "failure",    dotry_nak,    0,    0,    NULLCHAR,
  54.     "terminate",    dotry_terminate,    0,    0,    NULLCHAR,
  55.     NULLCHAR,
  56. };
  57.  
  58. static char *PPPStatus[] = {
  59.     "Physical Line Dead",
  60.     "Establishment Phase",
  61.     "Authentication Phase",
  62.     "Network Protocol Phase",
  63.     "Termination Phase"
  64. };
  65.  
  66. static char *NCPStatus[] = {
  67.     "Closed",
  68.     "Listening -- waiting for remote host to attempt open",
  69.     "Starting configuration exchange",
  70.     "Remote host accepted our request; waiting for remote request",
  71.     "We accepted remote request; waiting for reply to our request",
  72.     "Opened",
  73.     "Terminate request sent to remote host"
  74. };
  75.  
  76. int PPPtrace;
  77. struct iface *PPPiface;  /* iface for trace */
  78.  
  79.  
  80. /****************************************************************************/
  81.  
  82. static struct iface *
  83. ppp_lookup(ifname)
  84. char *ifname;
  85. {
  86.     register struct iface *ifp;
  87.  
  88.     if ((ifp = if_lookup(ifname)) == NULLIF) {
  89.         tprintf("%s: Interface unknown\n",ifname);
  90.         return(NULLIF);
  91.     }
  92.     if (ifp->type != CL_PPP) {
  93.         tprintf("%s: not a PPP interface\n",ifp->name);
  94.         return(NULLIF);
  95.     }
  96.     return(ifp);
  97. }
  98.  
  99. /****************************************************************************/
  100.  
  101. int
  102. doppp_commands(argc,argv,p)
  103. int argc;
  104. char *argv[];
  105. void *p;
  106. {
  107.     register struct iface *ifp;
  108.  
  109.     if (argc < 2) {
  110.         tprintf( "ppp <iface> required\n" );
  111.         return -1;
  112.     }
  113.     if ((ifp = ppp_lookup(argv[1])) == NULLIF)
  114.         return -1;
  115.  
  116.     if ( argc == 2 ) {
  117.         ppp_show( ifp );
  118.         return 0;
  119.     }
  120.  
  121.     return subcmd(Pppcmds, argc - 1, &argv[1], ifp);
  122. }
  123.  
  124.  
  125. /* Close connection on PPP interface */
  126. int
  127. doppp_close(argc,argv,p)
  128. int argc;
  129. char *argv[];
  130. void *p;
  131. {
  132.     register struct fsm_s *fsm_p = p;
  133.  
  134.     fsm_p->flags &= ~(FSM_ACTIVE | FSM_PASSIVE);
  135.  
  136.     fsm_close( fsm_p );
  137.     return 0;
  138. }
  139.  
  140.  
  141. int
  142. doppp_passive(argc,argv,p)
  143. int argc;
  144. char *argv[];
  145. void *p;
  146. {
  147.     register struct fsm_s *fsm_p = p;
  148.  
  149.     fsm_p->flags &= ~FSM_ACTIVE;
  150.     fsm_p->flags |= FSM_PASSIVE;
  151.  
  152.     fsm_start(fsm_p);
  153.     return 0;
  154. }
  155.  
  156.  
  157. int
  158. doppp_active(argc,argv,p)
  159. int argc;
  160. char *argv[];
  161. void *p;
  162. {
  163.     register struct fsm_s *fsm_p = p;
  164.  
  165.     fsm_p->flags &= ~FSM_PASSIVE;
  166.     fsm_p->flags |= FSM_ACTIVE;
  167.  
  168.     if ( fsm_p->state < fsmLISTEN ) {
  169.         fsm_p->state = fsmLISTEN;
  170.     }
  171.     return 0;
  172. }
  173.  
  174.  
  175. static int
  176. doppp_quick(argc,argv,p)
  177. int argc;
  178. char *argv[];
  179. void *p;
  180. {
  181.     register struct iface *ifp = p;
  182.     register struct ppp_s *ppp_p = ifp->edv;
  183.     struct lcp_s *lcp_p = ppp_p->fsm[Lcp].pdv;
  184.     struct ipcp_s *ipcp_p = ppp_p->fsm[IPcp].pdv;
  185.  
  186.     lcp_p->local.want.accm = 0L;
  187.     lcp_p->local.want.negotiate |= LCP_N_ACCM;
  188.     lcp_p->local.want.magic_number += (long)&lcp_p->local.want.magic_number;
  189.     lcp_p->local.want.negotiate |= LCP_N_MAGIC;
  190.     lcp_p->local.want.negotiate |= LCP_N_ACFC;
  191.     lcp_p->local.want.negotiate |= LCP_N_PFC;
  192.  
  193.     ipcp_p->local.want.compression = PPP_COMPR_PROTOCOL;
  194.     ipcp_p->local.want.slots = 16;
  195.     ipcp_p->local.want.slot_compress = 1;
  196.     ipcp_p->local.want.negotiate |= IPCP_N_COMPRESS;
  197.     doppp_active( 0, NULL, &(ppp_p->fsm[IPcp]) );
  198.  
  199.     return 0;
  200. }
  201.  
  202.  
  203. /****************************************************************************/
  204.  
  205. void
  206. ppp_show(ifp)
  207. struct iface *ifp;
  208. {
  209.     register struct ppp_s *ppp_p = ifp->edv;
  210.  
  211.     genstat(ppp_p);
  212.     if ( ppp_p->fsm[Lcp].pdv != NULL )
  213.         lcpstat(&(ppp_p->fsm[Lcp]));
  214.     if ( ppp_p->fsm[Pap].pdv != NULL )
  215.         papstat(&(ppp_p->fsm[Pap]));
  216.     if ( ppp_p->fsm[IPcp].pdv != NULL )
  217.         ipcpstat(&(ppp_p->fsm[IPcp]));
  218. }
  219.  
  220.  
  221. static void
  222. genstat(ppp_p)
  223. register struct ppp_s *ppp_p;
  224. {
  225.  
  226.     tprintf("%s", PPPStatus[ppp_p->phase]);
  227.  
  228.     if (ppp_p->phase == pppREADY) {
  229.         tprintf("\t(open for %s)",
  230.             tformat(secclock() - ppp_p->upsince));
  231.     }
  232.     tprintf("\n");
  233.  
  234.     tprintf("%10lu In,  %10lu Flags,%6u ME, %6u FE, %6u CSE, %6u other\n",
  235.         ppp_p->InRxOctetCount,
  236.         ppp_p->InOpenFlag,
  237.         ppp_p->InMemory,
  238.         ppp_p->InFrame,
  239.         ppp_p->InChecksum,
  240.         ppp_p->InError);
  241.     tprintf("\t\t%6u Lcp,%6u Pap,%6u IPcp,%6u Unknown\n",
  242.         ppp_p->InNCP[Lcp],
  243.         ppp_p->InNCP[Pap],
  244.         ppp_p->InNCP[IPcp],
  245.         ppp_p->InUnknown);
  246.     tprintf("%10lu Out, %10lu Flags,%6u ME, %6u Fail\n",
  247.         ppp_p->OutTxOctetCount,
  248.         ppp_p->OutOpenFlag,
  249.         ppp_p->OutMemory,
  250.         ppp_p->OutError);
  251.     tprintf("\t\t%6u Lcp,%6u Pap,%6u IPcp\n",
  252.         ppp_p->OutNCP[Lcp],
  253.         ppp_p->OutNCP[Pap],
  254.         ppp_p->OutNCP[IPcp]);
  255. }
  256.  
  257.  
  258. static int
  259. spot(int16 work, int16 want, int16 will, int16 mask)
  260. {
  261.     char blot = ' ';
  262.     int result = (work & mask);
  263.  
  264.     if ( !(will & mask) ) {
  265.         blot = '*';
  266.     } else if ( (want ^ work) & mask ) {
  267.         blot = (result ? '+' : '-');
  268.     }
  269.     tprintf( "%c", blot );
  270.     return result;
  271. }
  272.  
  273. static void
  274. lcpstat(fsm_p)
  275. struct fsm_s *fsm_p;
  276. {
  277.     struct lcp_s *lcp_p = fsm_p->pdv;
  278.     struct lcp_value_s *localp = &(lcp_p->local.work);
  279.     int16  localwork = lcp_p->local.work.negotiate;
  280.     int16  localwant = lcp_p->local.want.negotiate;
  281.     int16  localwill = lcp_p->local.will_negotiate;
  282.     struct lcp_value_s *remotep = &(lcp_p->remote.work);
  283.     int16  remotework = lcp_p->remote.work.negotiate;
  284.     int16  remotewant = lcp_p->remote.want.negotiate;
  285.     int16  remotewill = lcp_p->remote.will_negotiate;
  286.  
  287.     tprintf("LCP %s\n",
  288.         NCPStatus[fsm_p->state]);
  289.  
  290.     tprintf("\t\t MRU\t ACCM\t\t AP\t PFC  ACFC Magic\n");
  291.  
  292.     tprintf("\tLocal:\t");
  293.  
  294.     spot( localwork, localwant, localwill, LCP_N_MRU );
  295.     tprintf( "%4d\t", localp->mru );
  296.  
  297.     spot( localwork, localwant, localwill, LCP_N_ACCM );
  298.     tprintf( "0x%08lx\t", localp->accm );
  299.  
  300.     if ( spot( localwork, localwant, localwill, LCP_N_AUTHENT ) ) {
  301.         switch ( localp->authentication ) {
  302.         case PPP_PAP_PROTOCOL:
  303.             tprintf( "Pap\t" );
  304.             break;
  305.         default:
  306.             tprintf( "0x%04x\t", localp->authentication);
  307.             break;
  308.         };
  309.     } else {
  310.         tprintf( "None\t" );
  311.     }
  312.  
  313.     tprintf( spot( localwork, localwant, localwill, LCP_N_PFC )
  314.          ? "Yes " : "No  " );
  315.     tprintf( spot( localwork, localwant, localwill, LCP_N_ACFC )
  316.          ? "Yes " : "No  " );
  317.  
  318.     spot( localwork, localwant, localwill, LCP_N_MAGIC );
  319.     if ( localp->magic_number != 0L ) {
  320.         tprintf( "0x%08lx\n", localp->magic_number );
  321.     } else {
  322.         tprintf( "unused\n" );
  323.     }
  324.  
  325.     tprintf("\tRemote:\t");
  326.  
  327.     spot( remotework, remotewant, remotewill, LCP_N_MRU );
  328.     tprintf( "%4d\t", remotep->mru );
  329.  
  330.     spot( remotework, remotewant, remotewill, LCP_N_ACCM );
  331.     tprintf( "0x%08lx\t", remotep->accm );
  332.  
  333.     if ( spot( remotework, remotewant, remotewill, LCP_N_AUTHENT ) ) {
  334.         switch ( remotep->authentication ) {
  335.         case PPP_PAP_PROTOCOL:
  336.             tprintf( "Pap\t" );
  337.             break;
  338.         default:
  339.             tprintf( "0x%04x\t", remotep->authentication);
  340.             break;
  341.         };
  342.     } else {
  343.         tprintf( "None\t" );
  344.     }
  345.  
  346.     tprintf( spot( remotework, remotewant, remotewill, LCP_N_PFC )
  347.          ? "Yes " : "No  " );
  348.     tprintf( spot( remotework, remotewant, remotewill, LCP_N_ACFC )
  349.          ? "Yes " : "No  " );
  350.  
  351.     spot( remotework, remotewant, remotewill, LCP_N_MAGIC );
  352.     if ( remotep->magic_number != 0L ) {
  353.         tprintf( "0x%08lx\n", remotep->magic_number );
  354.     } else {
  355.         tprintf( "unused\n" );
  356.     }
  357. }
  358.  
  359.  
  360. static void
  361. papstat(fsm_p)
  362. struct fsm_s *fsm_p;
  363. {
  364.     struct pap_s *pap_p = fsm_p->pdv;
  365.  
  366.     tprintf("PAP %s\n",
  367.         NCPStatus[fsm_p->state]);
  368.  
  369.     tprintf( "\tMessage: '%s'\n", (pap_p->message == NULL) ?
  370.         "none" : pap_p->message );
  371. }
  372.  
  373.  
  374. static void
  375. ipcpstat(fsm_p)
  376. struct fsm_s *fsm_p;
  377. {
  378.     struct ipcp_s *ipcp_p = fsm_p->pdv;
  379.     struct ipcp_value_s *localp = &(ipcp_p->local.work);
  380.     int16  localwork = ipcp_p->local.work.negotiate;
  381.     struct ipcp_value_s *remotep = &(ipcp_p->remote.work);
  382.     int16  remotework = ipcp_p->remote.work.negotiate;
  383.  
  384.     tprintf("IPCP %s\n",
  385.         NCPStatus[fsm_p->state]);
  386.     tprintf("\tlocal IP address: %s",
  387.         inet_ntoa(localp->address));
  388.     tprintf("  remote IP address: %s\n",
  389.         inet_ntoa(localp->other));
  390.  
  391.     if (localwork & IPCP_N_COMPRESS) {
  392.         tprintf("    In\tTCP header compression enabled:"
  393.             " slots = %d, flag = 0x%02x\n",
  394.             localp->slots,
  395.             localp->slot_compress);
  396.         slhc_i_status(ipcp_p->slhcp);
  397.     }
  398.  
  399.     if (remotework & IPCP_N_COMPRESS) {
  400.         tprintf("    Out\tTCP header compression enabled:"
  401.             " slots = %d, flag = 0x%02x\n",
  402.             remotep->slots,
  403.             remotep->slot_compress);
  404.         slhc_o_status(ipcp_p->slhcp);
  405.     }
  406. }
  407.  
  408.  
  409. /****************************************************************************/
  410. /* Set timeout interval when waiting for response from remote peer */
  411. int
  412. doppp_timeout(argc,argv,p)
  413. int argc;
  414. char *argv[];
  415. void *p;
  416. {
  417.     struct fsm_s *fsm_p = p;
  418.     struct timer *t = &(fsm_p->timer);
  419.  
  420.     if (argc < 2) {
  421.         tprintf("%d\n",dur_timer(t)/1000L);
  422.     } else {
  423.         int x = (int)strtol( argv[1], NULLCHARP, 0 );
  424.  
  425.         if (x <= 0) {
  426.             tprintf("Timeout value %s (%d) must be > 0\n",
  427.                 argv[1], x);
  428.             return -1;
  429.         } else {
  430.             set_timer(t, x * 1000L);
  431.         }
  432.     }
  433.     return 0;
  434. }
  435.  
  436.  
  437. int
  438. doppp_try(argc,argv,p)
  439. int argc;
  440. char *argv[];
  441. void *p;
  442. {
  443.     return subcmd(PppTrycmds, argc, argv, p);
  444. }
  445.  
  446.  
  447. static int
  448. dotry_nak(argc,argv,p)
  449. int argc;
  450. char *argv[];
  451. void *p;
  452. {
  453.     struct fsm_s *fsm_p = p;
  454.  
  455.     if (argc < 2) {
  456.         tprintf("%d\n",fsm_p->try_nak);
  457.     } else {
  458.         int x = (int)strtol( argv[1], NULLCHARP, 0 );
  459.  
  460.         if (x <= 0) {
  461.             tprintf("Value %s (%d) must be > 0\n",
  462.                 argv[1], x);
  463.             return -1;
  464.         } else {
  465.             fsm_p->try_nak = x;
  466.         }
  467.     }
  468.     return 0;
  469. }
  470.  
  471.  
  472. static int
  473. dotry_req(argc,argv,p)
  474. int argc;
  475. char *argv[];
  476. void *p;
  477. {
  478.     struct fsm_s *fsm_p = p;
  479.  
  480.     if (argc < 2) {
  481.         tprintf("%d\n",fsm_p->try_req);
  482.     } else {
  483.         int x = (int)strtol( argv[1], NULLCHARP, 0 );
  484.  
  485.         if (x <= 0) {
  486.             tprintf("Value %s (%d) must be > 0\n",
  487.                 argv[1], x);
  488.             return -1;
  489.         } else {
  490.             fsm_p->try_req = x;
  491.         }
  492.     }
  493.     return 0;
  494. }
  495.  
  496.  
  497. static int
  498. dotry_terminate(argc,argv,p)
  499. int argc;
  500. char *argv[];
  501. void *p;
  502. {
  503.     struct fsm_s *fsm_p = p;
  504.  
  505.     if (argc < 2) {
  506.         tprintf("%d\n",fsm_p->try_terminate);
  507.     } else {
  508.         int x = (int)strtol( argv[1], NULLCHARP, 0 );
  509.  
  510.         if (x <= 0) {
  511.             tprintf("Value %s (%d) must be > 0\n",
  512.                 argv[1], x);
  513.             return -1;
  514.         } else {
  515.             fsm_p->try_terminate = x;
  516.         }
  517.     }
  518.     return 0;
  519. }
  520.  
  521.  
  522. static int
  523. doppp_trace(argc,argv,p)
  524. int argc;
  525. char *argv[];
  526. void *p;
  527. {
  528.     register struct iface *ifp = p;
  529.     register struct ppp_s *ppp_p = ifp->edv;
  530.     int tracing = ppp_p->trace;
  531.     int result = setint(&tracing,"PPP tracing",argc,argv);
  532.  
  533.     ppp_p->trace = tracing;
  534.     return result;
  535. }
  536.  
  537.  
  538.